﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Globalization;
using System.Windows.Media;
/*****************************************************************************************************************     

     
 Copyright © 2010 - Banco Itaú BBA S.A          
         
 PageGarantiaContrato:
            
 Histórico de Alterações:      
  28/10/2010 - Aline Abreu Alves (AAALVES)	- Criacao OS423540 
  14/10/2011 - Alexandre Nascimento

 *****************************************************************************************************************/

namespace ibba.src.norisk
{
    public partial class PageGarantiaContrato : Page
    {

        #region VARIAVEIS

        private List<ServiceGarantiaContrato.GarantiaContrato> _garantiaContrato;

        private List<ServiceGarantiaContrato.GarantiaContrato> _listaDistinct;

        private PageGarantiaContratoImpExcel _pageGarantiaContratoImpExcel;

        private PageGarantiaContratoExpExcel _pageGarantiaContratoExpExcel;

        private PageGarantiaContratoPresenter _pageGarantiaContratoPresenter;

        private decimal _percpercHE;

        private decimal _percpercHV;

        private decimal _percpercLMM;

        private bool retorno;

        private List<CadastroUtilizar> _listUtilizar;

        private List<CadastroIncondicional> _listIncondicional;

        #endregion

        #region CONSTRUTOR

        public PageGarantiaContrato()
        {
            InitializeComponent();

            _pageGarantiaContratoPresenter = new PageGarantiaContratoPresenter();

            _listUtilizar = new List<CadastroUtilizar>();

            _listUtilizar.Add(new CadastroUtilizar() { IndUtilizar = 0, strUtilizar = "EAD" });

            _listUtilizar.Add(new CadastroUtilizar() { IndUtilizar = 1, strUtilizar = "LIMITE" });

            _listUtilizar.Add(new CadastroUtilizar() { IndUtilizar = 2, strUtilizar = "AMBOS" });

            _listUtilizar.Add(new CadastroUtilizar() { IndUtilizar = 3, strUtilizar = "NENHUM" });

            _listIncondicional = new List<CadastroIncondicional>();

            _listIncondicional.Add(new CadastroIncondicional() { IndIncondicional = 0, strIncondicional = "NÃO" });

            _listIncondicional.Add(new CadastroIncondicional() { IndIncondicional = 1, strIncondicional = "SIM" });

            _pageGarantiaContratoImpExcel = new PageGarantiaContratoImpExcel();

            _pageGarantiaContratoExpExcel = new PageGarantiaContratoExpExcel();

            CarregarBarraBotoes();
        }

        #endregion

        #region METODOS

        //METODO QUE CARREGA OS BOTOES DA BARRA DE MENUS INFERIOR
        private void CarregarBarraBotoes()
        {
            App.MainPage.barraMenu.ClearButtons();

            //BOTAO SALVAR
            App.MainPage.barraMenu.AddNewButton(Constantes.EnumBotoes.BOTAO_SALVAR.ToString(),
                                                "Salvar",
                                                Constantes.SourceImagem.BOTAO_SALVAR,
                                                0,
                                                new ibba.src.slcomponentes.ControlMenuBar.Botao.DelegateClick(btnGravar_Click));
            App.MainPage.barraMenu.AlterarVisibilidadeBotao(Constantes.EnumBotoes.BOTAO_SALVAR.ToString(), AppHelper.Perfil.Contains("master"));

            App.MainPage.barraMenu.AtualizarControles();
        }


        //METODO QUE EXIBE MENSAGEM DE CARREGANDO NA TELA
        private void ExibeCarregando(bool enable, string busyContent)
        {
            activity.BusyContent = busyContent;
            activity.IsBusy = enable;
            App.MainPage.barraMenu.VisibilityButtons = enable ? System.Windows.Visibility.Collapsed : System.Windows.Visibility.Visible;
        }

        //METODO QUE ALTERA O CURSOR PARA AGUARDANDO
        private void AlterarCursorParaAguardando()
        {
            this.Cursor = System.Windows.Input.Cursors.Wait;
        }

        //METODO QUE ALTERA O CURSOR PARA O MODO NORMAL
        private void AlterarCursorParaModoNormal()
        {
            this.Cursor = System.Windows.Input.Cursors.Arrow;
        }

        //METODO DE PESQUISA DE CONTRATO
        private void PesquisarContrato()
        {
            if (txtContrato.Text.Length < 3)
            {
                MessageBoxHelper.ShowWarning("Aviso", "Mínimo de três caracteres para pesquisar.");
                return;
            }

            if (string.IsNullOrEmpty(txtCliente.Text) && string.IsNullOrEmpty(txtContrato.Text) && string.IsNullOrEmpty(txtGrupoEconomico.Text))
            {
                MessageBoxHelper.ShowWarning("Aviso", "Informe corretamente os campos para pesquisa");

                AlterarCursorParaModoNormal();
                ExibeCarregando(false, null);
                return;
            }

            if (!string.IsNullOrEmpty(txtContrato.Text))
            {
                ExibeCarregando(true, "Carregando...");
                AlterarCursorParaAguardando();

                this.CarregarListaGarantiaContrato(txtContrato.Text);
            }
        }


        private void CarregaSourcePesquisa()
        {
            this.CarregarListaGarantiaContrato(txtContrato.Text);
        }


        //METODO QUE CARREGA A LISTA DE GARANTIA/CONTRATO PELO CODIGO DO CONTRATO
        private void CarregarListaGarantiaContrato(string codContrato)
        {
            _pageGarantiaContratoPresenter.ObterGarantiaContrato(codContrato, CallBackObterGarantiaContrato);
            this.CarregarListaGarantiaContratoOriginal(codContrato);
        }
        private void CallBackObterGarantiaContrato(IAsyncResult pAsyncResult)
        {
            this.Dispatcher.BeginInvoke(delegate()
            {
                try
                {
                    _garantiaContrato = new List<ServiceGarantiaContrato.GarantiaContrato>();
                    _garantiaContrato = ((ServiceGarantiaContrato.IGarantiaContrato)pAsyncResult.AsyncState).EndObterGarantiaContrato(pAsyncResult);

                    if (_garantiaContrato.Count > 0)
                    {
                        grdGarantiaContrato.ItemsSource = _garantiaContrato;

                        txtContrato.ItemsSource = (from p in _garantiaContrato select p.CodContrato.Trim()).Distinct();

                        this.CarregaDetalhesContrato();
                    }
                    else
                    {
                        grdGarantiaContrato.ItemsSource = null;
                        MessageBoxHelper.ShowWarning("Aviso", "Não há garantias para este contrato.");
                        LimpaDetalhesContrato();
                    }
                }
                catch (System.ServiceModel.FaultException ex)
                {
                    MessageBoxHelper.ShowErro("Erro", string.Format("Ocorreu um erro ao buscar dados. {0}{1}", Environment.NewLine, ex.Message.ToString()), ex.StackTrace);
                }
                finally
                {
                    AlterarCursorParaModoNormal();
                    ExibeCarregando(false, "Carregando...");
                }
            });
        }


        private void CarregarListaGarantiaContratoOriginal(string codContrato)
        {
            _pageGarantiaContratoPresenter.ObterGarantiaContrato(codContrato, CallBackObterGarantiaContratoOriginal);

        }
        private void CallBackObterGarantiaContratoOriginal(IAsyncResult pAsyncResult)
        {
            this.Dispatcher.BeginInvoke(delegate()
            {
                try
                {
                    _listaDistinct = new List<ServiceGarantiaContrato.GarantiaContrato>();
                    _listaDistinct = ((ServiceGarantiaContrato.IGarantiaContrato)pAsyncResult.AsyncState).EndObterGarantiaContrato(pAsyncResult);
                }
                catch (System.ServiceModel.FaultException ex)
                {
                    MessageBoxHelper.ShowErro("Erro", string.Format("Ocorreu um erro ao buscar dados. {0}{1}", Environment.NewLine, ex.Message.ToString()), ex.StackTrace);
                }
                finally
                {
                    AlterarCursorParaModoNormal();
                    ExibeCarregando(false, "Carregando...");
                }
            });
        }


        //METODO QUE CARREGA OS DETALHES DO CONTRATO
        private void CarregaDetalhesContrato()
        {
            txtClienteDet.Text = _garantiaContrato[0].NomCliente;
            txtContratoDet.Text = _garantiaContrato[0].CodContrato;
            txtGrupoEconomicoDet.Text = _garantiaContrato[0].NomGrupoCliente;
        }

        //METODO QUE LIMPA OS DETALHES DO CONTRATO
        private void LimpaDetalhesContrato()
        {
            txtClienteDet.Text = "-";
            txtContratoDet.Text = "-";
            txtGrupoEconomicoDet.Text = "-";
        }



        private void Salvar(List<ibba.src.norisk.ServiceGarantiaContrato.GarantiaContrato> _list)
        {

            var _listDistinc = from employeeA in _list
                               join employeeB in _listaDistinct on employeeA.id equals employeeB.id
                               where
                               (employeeA.PercHE != employeeB.PercHE ||
                               employeeA.PercHV != employeeB.PercHV ||
                               employeeA.PercLMM != employeeB.PercLMM ||
                               employeeA.Utilizar != employeeB.Utilizar ||
                               employeeA.Incondicional != employeeB.Incondicional)
                               select employeeA;

            // Atualizar utilizar 0-EAD 1-LIMITE 2-AMBOS 3-NENHUM                          
            var lista = (from d in _listDistinc.ToList()
                         where (d.Utilizar == "EAD")
                         select new ServiceGarantiaContrato.GarantiaContrato
                         {
                             CodBem = d.CodBem,
                             CodCliente = d.CodCliente,
                             CodContrato = d.CodContrato,
                             CodGarantia = d.CodGarantia,
                             CodGarantidor = d.CodGarantidor,
                             CodInstrumento = d.CodInstrumento,
                             CodNatureza = d.CodNatureza,
                             DscBem = d.DscBem,
                             DscGarantia = d.DscGarantia,
                             DscGarantidor = d.DscGarantidor,
                             DscInstrumento = d.DscInstrumento,
                             DscNatureza = d.DscNatureza,
                             NomCliente = d.NomCliente,
                             PercHE = d.PercHE,
                             PercHV = d.PercHV,
                             PercLMM = d.PercLMM,
                             Utilizar = "0",
                             Incondicional = (d.Incondicional == "NÃO") ? "0" : "1"
                         })
                         .Union(from x in _listDistinc.ToList()
                                where x.Utilizar == "LIMITE"
                                select new ServiceGarantiaContrato.GarantiaContrato
                                {
                                    CodBem = x.CodBem,
                                    CodCliente = x.CodCliente,
                                    CodContrato = x.CodContrato,
                                    CodGarantia = x.CodGarantia,
                                    CodGarantidor = x.CodGarantidor,
                                    CodInstrumento = x.CodInstrumento,
                                    CodNatureza = x.CodNatureza,
                                    DscBem = x.DscBem,
                                    DscGarantia = x.DscGarantia,
                                    DscGarantidor = x.DscGarantidor,
                                    DscInstrumento = x.DscInstrumento,
                                    DscNatureza = x.DscNatureza,
                                    NomCliente = x.NomCliente,
                                    PercHE = x.PercHE,
                                    PercHV = x.PercHV,
                                    PercLMM = x.PercLMM,
                                    Utilizar = "1",
                                    Incondicional = (x.Incondicional == "NÃO") ? "0" : "1"
                                })
                                     .Union(from a in _listDistinc.ToList()
                                            where a.Utilizar == "AMBOS"
                                            select new ServiceGarantiaContrato.GarantiaContrato
                                            {
                                                CodBem = a.CodBem,
                                                CodCliente = a.CodCliente,
                                                CodContrato = a.CodContrato,
                                                CodGarantia = a.CodGarantia,
                                                CodGarantidor = a.CodGarantidor,
                                                CodInstrumento = a.CodInstrumento,
                                                CodNatureza = a.CodNatureza,
                                                DscBem = a.DscBem,
                                                DscGarantia = a.DscGarantia,
                                                DscGarantidor = a.DscGarantidor,
                                                DscInstrumento = a.DscInstrumento,
                                                DscNatureza = a.DscNatureza,
                                                NomCliente = a.NomCliente,
                                                PercHE = a.PercHE,
                                                PercHV = a.PercHV,
                                                PercLMM = a.PercLMM,
                                                Utilizar = "2",
                                                Incondicional = (a.Incondicional == "NÃO") ? "0" : "1"
                                            }).Union(from a in _listDistinc.ToList()
                                                     where a.Utilizar == "NENHUM"
                                                     select new ServiceGarantiaContrato.GarantiaContrato
                                                     {
                                                         CodBem = a.CodBem,
                                                         CodCliente = a.CodCliente,
                                                         CodContrato = a.CodContrato,
                                                         CodGarantia = a.CodGarantia,
                                                         CodGarantidor = a.CodGarantidor,
                                                         CodInstrumento = a.CodInstrumento,
                                                         CodNatureza = a.CodNatureza,
                                                         DscBem = a.DscBem,
                                                         DscGarantia = a.DscGarantia,
                                                         DscGarantidor = a.DscGarantidor,
                                                         DscInstrumento = a.DscInstrumento,
                                                         DscNatureza = a.DscNatureza,
                                                         NomCliente = a.NomCliente,
                                                         PercHE = a.PercHE,
                                                         PercHV = a.PercHV,
                                                         PercLMM = a.PercLMM,
                                                         Utilizar = "3",
                                                         Incondicional = (a.Incondicional == "NÃO") ? "0" : "1"
                                                     });


            if ((lista.ToList() != null) && (lista.Count() > 0))
            {
                var listaOK = from x in lista
                              select x.Set(x1 =>
                              {
                                  x.PercHV = x.PercHV / 100;
                                  x.PercHE = x.PercHE / 100;
                              });

                this.AlterarCursorParaAguardando();
                this.SalvarListaGarantiaContrato(listaOK.ToList());
            }
            else
            {
                MessageBoxHelper.ShowWarning("Aviso", "Não há itens a serem gravados");
                ExibeCarregando(false, null);
            }
        }


        //METODO QUE USADO PARA SALVAR UMA LISTA DE GARANTIA/CONTRATO
        private void SalvarListaGarantiaContrato(List<ibba.src.norisk.ServiceGarantiaContrato.GarantiaContrato> _list)
        {
            _pageGarantiaContratoPresenter.AtualizarGarantiaContrato(_list, AppHelper.LoginUsuario, false, CallBackAtualizaListaGarantiaContrato);
        }
        private void CallBackAtualizaListaGarantiaContrato(IAsyncResult pAsyncResult)
        {
            this.Dispatcher.BeginInvoke(delegate()
            {
                try
                {
                    int r = ((ServiceGarantiaContrato.IGarantiaContrato)pAsyncResult.AsyncState).EndAtualizarGarantiaContrato(pAsyncResult);

                    if (r != 0)
                    {
                        MessageBoxHelper.ShowSucess("NORISK", "Dados gravados com Sucesso");

                        this.CarregarListaGarantiaContrato(this.txtContrato.Text);
                        this.CarregarListaGarantiaContratoOriginal(this.txtContrato.Text);

                        return;
                    }
                    else
                    {
                        MessageBoxHelper.ShowErro("NORISK", "Ocorreu erro ao atualizar dados", null);
                    }
                }
                catch (System.ServiceModel.FaultException ex)
                {
                    MessageBoxHelper.ShowErro("Erro", string.Format("Ocorreu um erro ao atualizar dados. {0}{1}", Environment.NewLine, ex.Message.ToString()), ex.StackTrace);
                }
                finally
                {
                    AlterarCursorParaModoNormal();
                    ExibeCarregando(false, "Carregando...");
                }


            });

        }



        #endregion

        #region EVENTOS

        //EVENTO DO BOTAO DE PESQUISA
        private void btnPesquisar_Click(object sender, RoutedEventArgs e)
        {
            this.PesquisarContrato();
        }

        //EVENTO DE CARREGAR DADOS NA GRID
        private void grdGarantiaContrato_LoadingRow(object sender, DataGridRowEventArgs e)
        {
            const int IC_UTILIZAR = 6;

            ComboBox cboUtilizar = grdGarantiaContrato.Columns[IC_UTILIZAR].GetCellContent(e.Row) as ComboBox;

            var lista = (from p in _listUtilizar
                         where p.strUtilizar.Trim().ToLower() ==

((ibba.src.norisk.ServiceGarantiaContrato.GarantiaContrato)(e.Row.DataContext)).Utilizar.ToString().Trim().ToLower()
                         select p).ToList();

            cboUtilizar.ItemsSource = _listUtilizar;

            cboUtilizar.DisplayMemberPath = "strUtilizar";
            cboUtilizar.SelectedItem = "IndUtilizar";

            cboUtilizar.SelectedIndex = lista[0].IndUtilizar;


            ComboBox cboIncondicional = grdGarantiaContrato.Columns[7].GetCellContent(e.Row) as ComboBox;
            var listaIncondicional = (from p in _listIncondicional
                                      where p.strIncondicional.Trim().ToLower() == ((ibba.src.norisk.ServiceGarantiaContrato.GarantiaContrato)(e.Row.DataContext)).Incondicional.ToString().Trim().ToLower()
                                      select p).ToList();

            cboIncondicional.ItemsSource = _listIncondicional;
            cboIncondicional.DisplayMemberPath = "strIncondicional";
            cboIncondicional.SelectedItem = "indIncondicional";
            cboIncondicional.SelectedIndex = listaIncondicional[0].IndIncondicional;

        }

        private void cboUtilizar_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {

            string _novoUtilizar;

            if (grdGarantiaContrato.SelectedIndex != -1)
            {
                _novoUtilizar = ((ibba.src.norisk.CadastroUtilizar)(((System.Windows.Controls.ComboBox)(sender)).SelectedItem)).strUtilizar;

                ((ServiceGarantiaContrato.GarantiaContrato)grdGarantiaContrato.SelectedItem).Utilizar = _novoUtilizar;

            }
        }

        private void cboIncondicional_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            string _novoIncondicional;

            if (grdGarantiaContrato.SelectedIndex != -1)
            {
                _novoIncondicional = ((ibba.src.norisk.CadastroIncondicional)(((System.Windows.Controls.ComboBox)(sender)).SelectedItem)).strIncondicional;

                ((ServiceGarantiaContrato.GarantiaContrato)grdGarantiaContrato.SelectedItem).Incondicional = _novoIncondicional;
            }
        }

        //EVENTO QUE PESQUISA ENQUANTO É DIGITADO UM CONTRATO
        private void txtContrato_KeyDown(object sender, System.Windows.Input.KeyEventArgs e)
        {
            if (txtContrato.Text.Length < 3)
            {
                return;
            }

            if (e.Key == System.Windows.Input.Key.Enter)
            {
                this.PesquisarContrato();
            }
            else
            {
                CarregaSourcePesquisa();
            }
        }

        //EVENTO DO BOTAO SALVAR
        private void btnGravar_Click()
        {
            string _percHE;
            string _percHV;
            string _percLMM;
            decimal resultado;
            retorno = true;

            if (grdGarantiaContrato.ItemsSource != null)
            {

                List<ServiceGarantiaContrato.GarantiaContrato> Lista = new List<ServiceGarantiaContrato.GarantiaContrato>();

                Lista = (List<ibba.src.norisk.ServiceGarantiaContrato.GarantiaContrato>)grdGarantiaContrato.ItemsSource;


                foreach (ServiceGarantiaContrato.GarantiaContrato itemGarantiaContrato in Lista)
                {
                    /*Validar HE*/
                    _percHE = Convert.ToString(itemGarantiaContrato.PercHE);

                    if (_percHE != "")
                    {

                        _percpercHE = Convert.ToDecimal(_percHE);

                        if (_percpercHE == null)
                        {
                            MessageBoxHelper.ShowWarning("Aviso", "Atenção: preencher todos os registros.");
                            retorno = false;
                            return;
                        }
                        else if (!decimal.TryParse(_percHE, out resultado))
                        {
                            MessageBoxHelper.ShowWarning("NORISK", "Atenção:  Digitar valores válidos.");
                            retorno = false;
                            return;
                        }
                        else if (_percpercHE < 0)
                        {
                            MessageBoxHelper.ShowWarning("NORISK", "Valor Negativo não é permitido.");
                            retorno = false;
                            return;
                        }
                        else if (_percpercHE > 100)
                        {
                            MessageBoxHelper.ShowWarning("NORISK", "Digitar um valor no percentual de HE, " +
                                           "que seja um valor numérico válido entre 0 e 100.");
                            retorno = false;
                            return;
                        }
                    }
                    else
                    {
                        MessageBoxHelper.ShowWarning("NORISK", "Digitar um valor no percentual de HE, " +
                                           "que seja um valor numérico válido entre 0 e 100.");
                        retorno = false;
                        return;
                    }
                    /* Validar HV */

                    _percHV = Convert.ToString(itemGarantiaContrato.PercHV);

                    if (_percHV != "")
                    {

                        _percpercHV = Convert.ToDecimal(_percHV);

                        if (_percpercHV == null)
                        {
                            MessageBoxHelper.ShowWarning("NORISK", "Atenção: preencher todos os registros.");
                            retorno = false;
                            return;
                        }
                        else if (!decimal.TryParse(_percHV, out resultado))
                        {
                            MessageBoxHelper.ShowWarning("NORISK", "Atenção:  Digitar valores válidos.");
                            retorno = false;
                            return;
                        }
                        else if (_percpercHV < 0)
                        {
                            MessageBoxHelper.ShowWarning("NORISK", "Valor Negativo não é permitido.");
                            retorno = false;
                            return;
                        }
                        else if (_percpercHV > 100)
                        {
                            MessageBoxHelper.ShowWarning("NORISK", "Digitar um valor no percentual de HV, " +
                                           "que seja um valor numérico válido entre 0 e 100.");
                            retorno = false;
                            return;
                        }

                    }
                    else
                    {
                        MessageBoxHelper.ShowWarning("NORISK", "Digitar um valor no percentual de HV, " +
                                                                   "que seja um valor numérico válido entre 0 e 100.");
                        retorno = false;
                        return;

                    }

                    /* Validar LMM */

                    _percLMM = Convert.ToString(itemGarantiaContrato.PercLMM);

                    if (_percLMM != "")
                    {
                        _percpercLMM = Convert.ToDecimal(_percLMM);

                        if (_percpercHV == null)
                        {
                            MessageBoxHelper.ShowWarning("NORISK", "Atenção: preencher todos os registros.");
                            retorno = false;
                            return;
                        }
                        else if (!decimal.TryParse(_percLMM, out resultado))
                        {
                            MessageBoxHelper.ShowWarning("NORISK", "Atenção:  Digitar valores válidos.");
                            retorno = false;
                            return;
                        }
                        else if (_percpercLMM < 0)
                        {
                            MessageBoxHelper.ShowWarning("NORISK", "Valor Negativo não permitido.");
                            retorno = false;
                            return;
                        }
                        else if (_percpercLMM > 100)
                        {
                            MessageBoxHelper.ShowWarning("NORISK", "Digitar um valor no percentual de LMM, " +
                                           "que seja um valor numérico válido entre 0 e 100.");
                            retorno = false;
                            return;
                        }
                    }
                    else
                    {
                        MessageBoxHelper.ShowWarning("NORISK", "Digitar um valor no percentual de LMM, " +
                                           "que seja um valor numérico válido entre 0 e 100.");
                        retorno = false;
                        return;
                    }

                }
                if (retorno)
                {
                    ExibeCarregando(true, "Gravando...");

                    List<ibba.src.norisk.ServiceGarantiaContrato.GarantiaContrato> _lista = new List<ibba.src.norisk.ServiceGarantiaContrato.GarantiaContrato>();

                    _lista = (List<ibba.src.norisk.ServiceGarantiaContrato.GarantiaContrato>)grdGarantiaContrato.ItemsSource;

                    this.Salvar(_lista);
                }
            }
            else
            {
                MessageBoxHelper.ShowWarning("Aviso", "Não há dados a serem salvos");
            }
        }

        #endregion
    }


    public class CadastroIncondicional
    {
        public int IndIncondicional { get; set; }
        public string strIncondicional { get; set; }
    }
}